package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:22
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductVersionDAOQueryBean extends BaseQueryBean {
    public ProductVersionDAOQueryBean() {
        super();
    }

    public ProductVersionDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductVersionDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.Id, "id");
        }
    }

    public void addProductDefineIdSelectProperty() {
        addProductDefineIdSelectProperty("productDefineId");
    }

    public void addProductDefineIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductDefineId, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductDefineId,
                "productDefineId");
        }
    }

    public void addProductVersionSelectProperty() {
        addProductVersionSelectProperty("productVersion");
    }

    public void addProductVersionSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductVersion, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductVersion,
                "productVersion");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.Remarks, "remarks");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.Status, "status");
        }
    }

    public void addProductVersionTypeSelectProperty() {
        addProductVersionTypeSelectProperty("productVersionType");
    }

    public void addProductVersionTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductVersionType, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductVersionType,
                "productVersionType");
        }
    }

    public void addParentVersionIdSelectProperty() {
        addParentVersionIdSelectProperty("parentVersionId");
    }

    public void addParentVersionIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ParentVersionId, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ParentVersionId,
                "parentVersionId");
        }
    }

    public void addStartDateSelectProperty() {
        addStartDateSelectProperty("startDate");
    }

    public void addStartDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.StartDate, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.StartDate, "startDate");
        }
    }

    public void addEndDateSelectProperty() {
        addEndDateSelectProperty("endDate");
    }

    public void addEndDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.EndDate, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.EndDate, "endDate");
        }
    }

    public void addActualStartDateSelectProperty() {
        addActualStartDateSelectProperty("actualStartDate");
    }

    public void addActualStartDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ActualStartDate, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ActualStartDate,
                "actualStartDate");
        }
    }

    public void addActualEndDateSelectProperty() {
        addActualEndDateSelectProperty("actualEndDate");
    }

    public void addActualEndDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ActualEndDate, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ActualEndDate, "actualEndDate");
        }
    }

    public void addSortIndexSelectProperty() {
        addSortIndexSelectProperty("sortIndex");
    }

    public void addSortIndexSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.SortIndex, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.SortIndex, "sortIndex");
        }
    }

    public void addProductNameSelectProperty() {
        addProductNameSelectProperty("productName");
    }

    public void addProductNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductName, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductName, "productName");
        }
    }

    public void addProductCdoeSelectProperty() {
        addProductCdoeSelectProperty("productCdoe");
    }

    public void addProductCdoeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductCdoe, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductCdoe, "productCdoe");
        }
    }

    public void addProductStatusSelectProperty() {
        addProductStatusSelectProperty("productStatus");
    }

    public void addProductStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductStatus, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductStatus, "productStatus");
        }
    }

    public void addProductRemarksSelectProperty() {
        addProductRemarksSelectProperty("productRemarks");
    }

    public void addProductRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ProductRemarks, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ProductRemarks,
                "productRemarks");
        }
    }

    public void addParentProductVersionSelectProperty() {
        addParentProductVersionSelectProperty("parentProductVersion");
    }

    public void addParentProductVersionSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ParentProductVersion, aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ParentProductVersion,
                "parentProductVersion");
        }
    }

    public void addParentProductVersionTypeSelectProperty() {
        addParentProductVersionTypeSelectProperty("parentProductVersionType");
    }

    public void addParentProductVersionTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ParentProductVersionType,
                aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ParentProductVersionType,
                "parentProductVersionType");
        }
    }

    public void addParentProductVersionStatusSelectProperty() {
        addParentProductVersionStatusSelectProperty(
            "parentProductVersionStatus");
    }

    public void addParentProductVersionStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionDAO.ParentProductVersionStatus,
                aAlias);
        } else {
            addSelectProperty(IProductVersionDAO.ParentProductVersionStatus,
                "parentProductVersionStatus");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addProductDefineIdSelectProperty();

        addProductVersionSelectProperty();

        addRemarksSelectProperty();

        addStatusSelectProperty();

        addProductVersionTypeSelectProperty();

        addParentVersionIdSelectProperty();

        addStartDateSelectProperty();

        addEndDateSelectProperty();

        addActualStartDateSelectProperty();

        addActualEndDateSelectProperty();

        addSortIndexSelectProperty();

        addProductNameSelectProperty();

        addProductCdoeSelectProperty();

        addProductStatusSelectProperty();

        addProductRemarksSelectProperty();

        addParentProductVersionSelectProperty();

        addParentProductVersionTypeSelectProperty();

        addParentProductVersionStatusSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductVersionDAOQueryBean> {
        protected Criteria(ProductVersionDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductVersionDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductVersionDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductVersionDAO.Id + " is not null AND " +
                IProductVersionDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductVersionDAO.Id + " is null OR " +
                IProductVersionDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " is null OR " +
                IProductVersionDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Id + " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductVersionDAO.Id + " between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionDAO.Id + " between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductVersionDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andProductDefineIdIsNull() {
            addCriterion(IProductVersionDAO.ProductDefineId + " is null");

            return this;
        }

        public Criteria andProductDefineIdIsNotNull() {
            addCriterion(IProductVersionDAO.ProductDefineId + " is not null");

            return this;
        }

        public Criteria andProductDefineIdIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductDefineId +
                " is not null AND " + IProductVersionDAO.ProductDefineId +
                " <> ''");

            return this;
        }

        public Criteria andProductDefineIdIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductDefineId +
                " is null OR " + IProductVersionDAO.ProductDefineId + " = '')");

            return this;
        }

        public Criteria andProductDefineIdEqualTo(long value) {
            return andProductDefineIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " = ", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductDefineId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(long value) {
            return andProductDefineIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " <>", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(long value) {
            return andProductDefineIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " is null OR " +
                IProductVersionDAO.ProductDefineId + " <>", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductDefineId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(long value) {
            return andProductDefineIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " >", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductDefineId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(long value) {
            return andProductDefineIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " >=", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductDefineId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThan(long value) {
            return andProductDefineIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThan(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " <", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductDefineId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(long value) {
            return andProductDefineIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductVersionDAO.ProductDefineId + " <=", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductDefineId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductDefineId + " not in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductDefineId + " not in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductDefineId + " in",
                    Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductDefineId + " not in",
                    Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductDefineId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdBetween(long value1, long value2) {
            addCriterion(IProductVersionDAO.ProductDefineId + " between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionDAO.ProductDefineId + " between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(long value1, long value2) {
            addCriterion(IProductVersionDAO.ProductDefineId + " not between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionDAO.ProductDefineId + " not between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductVersionIsNull() {
            addCriterion(IProductVersionDAO.ProductVersion + " is null");

            return this;
        }

        public Criteria andProductVersionIsNotNull() {
            addCriterion(IProductVersionDAO.ProductVersion + " is not null");

            return this;
        }

        public Criteria andProductVersionIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductVersion +
                " is not null AND " + IProductVersionDAO.ProductVersion +
                " <> ''");

            return this;
        }

        public Criteria andProductVersionIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductVersion +
                " is null OR " + IProductVersionDAO.ProductVersion + " = '')");

            return this;
        }

        public Criteria andProductVersionEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " = ", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersion);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " <>", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " is null OR " +
                IProductVersionDAO.ProductVersion + " <>", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersion);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " >", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersion);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " >=", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersion);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionLessThan(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " <", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersion);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersion + " <=", value,
                "productVersion");

            return this;
        }

        public Criteria andProductVersionLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersion);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductVersion + " like",
                buffer.toString(), "productVersion");

            return this;
        }

        public Criteria andProductVersionNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductVersion + " not like",
                buffer.toString(), "productVersion");

            return this;
        }

        public Criteria andProductVersionIn(List<String> values) {
            if (values.size() == 1) {
                return andProductVersionEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductVersion + " in", values,
                    "productVersion");

                return this;
            }
        }

        public Criteria andProductVersionNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductVersionNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductVersion + " not in",
                    values, "productVersion");

                return this;
            }
        }

        public Criteria andProductVersionIn(String[] values) {
            if (values.length == 1) {
                return andProductVersionEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductVersion + " in",
                    Arrays.asList(values), "productVersion");

                return this;
            }
        }

        public Criteria andProductVersionNotIn(String[] values) {
            if (values.length == 1) {
                return andProductVersionNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductVersion + " not in",
                    Arrays.asList(values), "productVersion");

                return this;
            }
        }

        public Criteria andProductVersionIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersion + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductVersion + " between",
                value1, value2, "productVersion");

            return this;
        }

        public Criteria andProductVersionNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductVersion + " not between",
                value1, value2, "productVersion");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductVersionDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductVersionDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductVersionDAO.Remarks + " is not null AND " +
                IProductVersionDAO.Remarks + " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductVersionDAO.Remarks + " is null OR " +
                IProductVersionDAO.Remarks + " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductVersionDAO.Remarks + " = ", value, "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.Remarks + " is null OR " +
                IProductVersionDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductVersionDAO.Remarks + " >", value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.Remarks + " >=", value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductVersionDAO.Remarks + " <", value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.Remarks + " <=", value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.Remarks + " in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.Remarks + " not in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Remarks + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.Remarks + " between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.Remarks + " not between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductVersionDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductVersionDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductVersionDAO.Status + " is not null AND " +
                IProductVersionDAO.Status + " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductVersionDAO.Status + " is null OR " +
                IProductVersionDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductVersionDAO.Status + " = ", value, "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.Status + " is null OR " +
                IProductVersionDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductVersionDAO.Status + " >", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.Status + " >=", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductVersionDAO.Status + " <", value, "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.Status + " <=", value, "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.Status + " in", values, "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.Status + " not in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.Status + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.Status + " between", value1,
                value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.Status + " not between", value1,
                value2, "status");

            return this;
        }

        public Criteria andProductVersionTypeIsNull() {
            addCriterion(IProductVersionDAO.ProductVersionType + " is null");

            return this;
        }

        public Criteria andProductVersionTypeIsNotNull() {
            addCriterion(IProductVersionDAO.ProductVersionType +
                " is not null");

            return this;
        }

        public Criteria andProductVersionTypeIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductVersionType +
                " is not null AND " + IProductVersionDAO.ProductVersionType +
                " <> ''");

            return this;
        }

        public Criteria andProductVersionTypeIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductVersionType +
                " is null OR " + IProductVersionDAO.ProductVersionType +
                " = '')");

            return this;
        }

        public Criteria andProductVersionTypeEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType + " = ", value,
                "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersionType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionTypeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType + " <>", value,
                "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType +
                " is null OR " + IProductVersionDAO.ProductVersionType + " <>",
                value, "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersionType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionTypeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType + " >", value,
                "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersionType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionTypeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType + " >=", value,
                "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersionType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeLessThan(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType + " <", value,
                "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersionType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionTypeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductVersionType + " <=", value,
                "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductVersionType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductVersionType + " like",
                buffer.toString(), "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductVersionType + " not like",
                buffer.toString(), "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductVersionTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductVersionType + " in",
                    values, "productVersionType");

                return this;
            }
        }

        public Criteria andProductVersionTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductVersionTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductVersionType + " not in",
                    values, "productVersionType");

                return this;
            }
        }

        public Criteria andProductVersionTypeIn(String[] values) {
            if (values.length == 1) {
                return andProductVersionTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductVersionType + " in",
                    Arrays.asList(values), "productVersionType");

                return this;
            }
        }

        public Criteria andProductVersionTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductVersionTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductVersionType + " not in",
                    Arrays.asList(values), "productVersionType");

                return this;
            }
        }

        public Criteria andProductVersionTypeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductVersionType + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionTypeBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ProductVersionType + " between",
                value1, value2, "productVersionType");

            return this;
        }

        public Criteria andProductVersionTypeNotBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ProductVersionType +
                " not between", value1, value2, "productVersionType");

            return this;
        }

        public Criteria andParentVersionIdIsNull() {
            addCriterion(IProductVersionDAO.ParentVersionId + " is null");

            return this;
        }

        public Criteria andParentVersionIdIsNotNull() {
            addCriterion(IProductVersionDAO.ParentVersionId + " is not null");

            return this;
        }

        public Criteria andParentVersionIdIsNotEmpty() {
            addCriterion(IProductVersionDAO.ParentVersionId +
                " is not null AND " + IProductVersionDAO.ParentVersionId +
                " <> ''");

            return this;
        }

        public Criteria andParentVersionIdIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ParentVersionId +
                " is null OR " + IProductVersionDAO.ParentVersionId + " = '')");

            return this;
        }

        public Criteria andParentVersionIdEqualTo(long value) {
            return andParentVersionIdEqualTo(Long.valueOf(value));
        }

        public Criteria andParentVersionIdEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " = ", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentVersionId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentVersionIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdNotEqualTo(long value) {
            return andParentVersionIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andParentVersionIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " <>", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdNotEqualToOrIsNull(long value) {
            return andParentVersionIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andParentVersionIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " is null OR " +
                IProductVersionDAO.ParentVersionId + " <>", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentVersionId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentVersionIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdGreaterThan(long value) {
            return andParentVersionIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andParentVersionIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " >", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentVersionId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentVersionIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdGreaterThanOrEqualTo(long value) {
            return andParentVersionIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andParentVersionIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " >=", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentVersionId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentVersionIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdLessThan(long value) {
            return andParentVersionIdLessThan(Long.valueOf(value));
        }

        public Criteria andParentVersionIdLessThan(java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " <", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentVersionId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentVersionIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdLessThanOrEqualTo(long value) {
            return andParentVersionIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andParentVersionIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductVersionDAO.ParentVersionId + " <=", value,
                "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentVersionId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentVersionIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdIn(long[] values) {
            if (values.length == 1) {
                return andParentVersionIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentVersionId + " in",
                    values, "parentVersionId");

                return this;
            }
        }

        public Criteria andParentVersionIdNotIn(long[] values) {
            if (values.length == 1) {
                return andParentVersionIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentVersionId + " not in",
                    values, "parentVersionId");

                return this;
            }
        }

        public Criteria andParentVersionIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andParentVersionIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentVersionId + " in",
                    values, "parentVersionId");

                return this;
            }
        }

        public Criteria andParentVersionIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andParentVersionIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentVersionId + " not in",
                    values, "parentVersionId");

                return this;
            }
        }

        public Criteria andParentVersionIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andParentVersionIdEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentVersionId + " in",
                    Arrays.asList(values), "parentVersionId");

                return this;
            }
        }

        public Criteria andParentVersionIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andParentVersionIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentVersionId + " not in",
                    Arrays.asList(values), "parentVersionId");

                return this;
            }
        }

        public Criteria andParentVersionIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentVersionId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentVersionIdBetween(long value1, long value2) {
            addCriterion(IProductVersionDAO.ParentVersionId + " between",
                value1, value2, "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionDAO.ParentVersionId + " between",
                value1, value2, "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdNotBetween(long value1, long value2) {
            addCriterion(IProductVersionDAO.ParentVersionId + " not between",
                value1, value2, "parentVersionId");

            return this;
        }

        public Criteria andParentVersionIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionDAO.ParentVersionId + " not between",
                value1, value2, "parentVersionId");

            return this;
        }

        public Criteria andStartDateIsNull() {
            addCriterion(IProductVersionDAO.StartDate + " is null");

            return this;
        }

        public Criteria andStartDateIsNotNull() {
            addCriterion(IProductVersionDAO.StartDate + " is not null");

            return this;
        }

        public Criteria andStartDateIsNotEmpty() {
            addCriterion(IProductVersionDAO.StartDate + " is not null AND " +
                IProductVersionDAO.StartDate + " <> ''");

            return this;
        }

        public Criteria andStartDateIsEmpty() {
            addCriterion("(" + IProductVersionDAO.StartDate + " is null OR " +
                IProductVersionDAO.StartDate + " = '')");

            return this;
        }

        public Criteria andStartDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " = ",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.StartDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " <>",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate +
                " is null OR " + IProductVersionDAO.StartDate + " <>", value,
                "startDate");

            return this;
        }

        public Criteria andStartDateNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.StartDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStartDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " >", value,
                "startDate");

            return this;
        }

        public Criteria andStartDateGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.StartDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " >=",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.StartDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStartDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " <", value,
                "startDate");

            return this;
        }

        public Criteria andStartDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.StartDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " <=",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.StartDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStartDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andStartDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.StartDate + " in",
                    values, "startDate");

                return this;
            }
        }

        public Criteria andStartDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andStartDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.StartDate +
                    " not in", values, "startDate");

                return this;
            }
        }

        public Criteria andStartDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andStartDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.StartDate + " in",
                    Arrays.asList(values), "startDate");

                return this;
            }
        }

        public Criteria andStartDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andStartDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.StartDate +
                    " not in", Arrays.asList(values), "startDate");

                return this;
            }
        }

        public Criteria andStartDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStartDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.StartDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate + " between",
                value1, value2, "startDate");

            return this;
        }

        public Criteria andStartDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.StartDate +
                " not between", value1, value2, "startDate");

            return this;
        }

        public Criteria andEndDateIsNull() {
            addCriterion(IProductVersionDAO.EndDate + " is null");

            return this;
        }

        public Criteria andEndDateIsNotNull() {
            addCriterion(IProductVersionDAO.EndDate + " is not null");

            return this;
        }

        public Criteria andEndDateIsNotEmpty() {
            addCriterion(IProductVersionDAO.EndDate + " is not null AND " +
                IProductVersionDAO.EndDate + " <> ''");

            return this;
        }

        public Criteria andEndDateIsEmpty() {
            addCriterion("(" + IProductVersionDAO.EndDate + " is null OR " +
                IProductVersionDAO.EndDate + " = '')");

            return this;
        }

        public Criteria andEndDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " = ", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.EndDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " <>", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate +
                " is null OR " + IProductVersionDAO.EndDate + " <>", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.EndDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " >", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.EndDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " >=", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.EndDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " <", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.EndDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " <=", value,
                "endDate");

            return this;
        }

        public Criteria andEndDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.EndDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEndDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.EndDate + " in",
                    values, "endDate");

                return this;
            }
        }

        public Criteria andEndDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEndDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.EndDate + " not in",
                    values, "endDate");

                return this;
            }
        }

        public Criteria andEndDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEndDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.EndDate + " in",
                    Arrays.asList(values), "endDate");

                return this;
            }
        }

        public Criteria andEndDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEndDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.EndDate + " not in",
                    Arrays.asList(values), "endDate");

                return this;
            }
        }

        public Criteria andEndDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.EndDate + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEndDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate + " between",
                value1, value2, "endDate");

            return this;
        }

        public Criteria andEndDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.EndDate +
                " not between", value1, value2, "endDate");

            return this;
        }

        public Criteria andActualStartDateIsNull() {
            addCriterion(IProductVersionDAO.ActualStartDate + " is null");

            return this;
        }

        public Criteria andActualStartDateIsNotNull() {
            addCriterion(IProductVersionDAO.ActualStartDate + " is not null");

            return this;
        }

        public Criteria andActualStartDateIsNotEmpty() {
            addCriterion(IProductVersionDAO.ActualStartDate +
                " is not null AND " + IProductVersionDAO.ActualStartDate +
                " <> ''");

            return this;
        }

        public Criteria andActualStartDateIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ActualStartDate +
                " is null OR " + IProductVersionDAO.ActualStartDate + " = '')");

            return this;
        }

        public Criteria andActualStartDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate + " = ",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualStartDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate + " <>",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateNotEqualToOrIsNull(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                " is null OR " + IProductVersionDAO.ActualStartDate + " <>",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualStartDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate + " >",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualStartDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate + " >=",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualStartDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate + " <",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualStartDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateLessThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate + " <=",
                value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualStartDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualStartDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                    " in", values, "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualStartDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                    " not in", values, "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualStartDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                    " in", Arrays.asList(values), "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualStartDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                    " not in", Arrays.asList(values), "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualStartDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                " between", value1, value2, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualStartDate +
                " not between", value1, value2, "actualStartDate");

            return this;
        }

        public Criteria andActualEndDateIsNull() {
            addCriterion(IProductVersionDAO.ActualEndDate + " is null");

            return this;
        }

        public Criteria andActualEndDateIsNotNull() {
            addCriterion(IProductVersionDAO.ActualEndDate + " is not null");

            return this;
        }

        public Criteria andActualEndDateIsNotEmpty() {
            addCriterion(IProductVersionDAO.ActualEndDate +
                " is not null AND " + IProductVersionDAO.ActualEndDate +
                " <> ''");

            return this;
        }

        public Criteria andActualEndDateIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ActualEndDate +
                " is null OR " + IProductVersionDAO.ActualEndDate + " = '')");

            return this;
        }

        public Criteria andActualEndDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate + " = ",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualEndDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate + " <>",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                " is null OR " + IProductVersionDAO.ActualEndDate + " <>",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualEndDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate + " >",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualEndDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate + " >=",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualEndDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate + " <",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualEndDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate + " <=",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ActualEndDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualEndDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                    " in", values, "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualEndDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                    " not in", values, "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualEndDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                    " in", Arrays.asList(values), "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualEndDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                    " not in", Arrays.asList(values), "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ActualEndDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                " between", value1, value2, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionDAO.ActualEndDate +
                " not between", value1, value2, "actualEndDate");

            return this;
        }

        public Criteria andSortIndexIsNull() {
            addCriterion(IProductVersionDAO.SortIndex + " is null");

            return this;
        }

        public Criteria andSortIndexIsNotNull() {
            addCriterion(IProductVersionDAO.SortIndex + " is not null");

            return this;
        }

        public Criteria andSortIndexIsNotEmpty() {
            addCriterion(IProductVersionDAO.SortIndex + " is not null AND " +
                IProductVersionDAO.SortIndex + " <> ''");

            return this;
        }

        public Criteria andSortIndexIsEmpty() {
            addCriterion("(" + IProductVersionDAO.SortIndex + " is null OR " +
                IProductVersionDAO.SortIndex + " = '')");

            return this;
        }

        public Criteria andSortIndexEqualTo(int value) {
            return andSortIndexEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexEqualTo(java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " = ", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.SortIndex);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexNotEqualTo(int value) {
            return andSortIndexNotEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexNotEqualTo(java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " <>", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotEqualToOrIsNull(int value) {
            return andSortIndexNotEqualToOrIsNull(Integer.valueOf(value));
        }

        public Criteria andSortIndexNotEqualToOrIsNull(java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " is null OR " +
                IProductVersionDAO.SortIndex + " <>", value, "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.SortIndex);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andSortIndexGreaterThan(int value) {
            return andSortIndexGreaterThan(Integer.valueOf(value));
        }

        public Criteria andSortIndexGreaterThan(java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " >", value, "sortIndex");

            return this;
        }

        public Criteria andSortIndexGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.SortIndex);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexGreaterThanOrEqualTo(int value) {
            return andSortIndexGreaterThanOrEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexGreaterThanOrEqualTo(
            java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " >=", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.SortIndex);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andSortIndexLessThan(int value) {
            return andSortIndexLessThan(Integer.valueOf(value));
        }

        public Criteria andSortIndexLessThan(java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " <", value, "sortIndex");

            return this;
        }

        public Criteria andSortIndexLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.SortIndex);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexLessThanOrEqualTo(int value) {
            return andSortIndexLessThanOrEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexLessThanOrEqualTo(java.lang.Integer value) {
            addCriterion(IProductVersionDAO.SortIndex + " <=", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.SortIndex);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andSortIndexIn(int[] values) {
            if (values.length == 1) {
                return andSortIndexEqualTo((java.lang.Integer) values[0]);
            } else {
                addCriterion(IProductVersionDAO.SortIndex + " in", values,
                    "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexNotIn(int[] values) {
            if (values.length == 1) {
                return andSortIndexNotEqualTo((java.lang.Integer) values[0]);
            } else {
                addCriterion(IProductVersionDAO.SortIndex + " not in", values,
                    "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexIn(List<java.lang.Integer> values) {
            if (values.size() == 1) {
                return andSortIndexEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.SortIndex + " in", values,
                    "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexNotIn(List<java.lang.Integer> values) {
            if (values.size() == 1) {
                return andSortIndexNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.SortIndex + " not in", values,
                    "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexIn(java.lang.Integer[] values) {
            if (values.length == 1) {
                return andSortIndexEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.SortIndex + " in",
                    Arrays.asList(values), "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexNotIn(java.lang.Integer[] values) {
            if (values.length == 1) {
                return andSortIndexNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.SortIndex + " not in",
                    Arrays.asList(values), "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andSortIndexNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.SortIndex + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexBetween(int value1, int value2) {
            addCriterion(IProductVersionDAO.SortIndex + " between", value1,
                value2, "sortIndex");

            return this;
        }

        public Criteria andSortIndexBetween(java.lang.Integer value1,
            java.lang.Integer value2) {
            addCriterion(IProductVersionDAO.SortIndex + " between", value1,
                value2, "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotBetween(int value1, int value2) {
            addCriterion(IProductVersionDAO.SortIndex + " not between", value1,
                value2, "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotBetween(java.lang.Integer value1,
            java.lang.Integer value2) {
            addCriterion(IProductVersionDAO.SortIndex + " not between", value1,
                value2, "sortIndex");

            return this;
        }

        public Criteria andProductNameIsNull() {
            addCriterion(IProductVersionDAO.ProductName + " is null");

            return this;
        }

        public Criteria andProductNameIsNotNull() {
            addCriterion(IProductVersionDAO.ProductName + " is not null");

            return this;
        }

        public Criteria andProductNameIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductName + " is not null AND " +
                IProductVersionDAO.ProductName + " <> ''");

            return this;
        }

        public Criteria andProductNameIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductName + " is null OR " +
                IProductVersionDAO.ProductName + " = '')");

            return this;
        }

        public Criteria andProductNameEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductName + " = ", value,
                "productName");

            return this;
        }

        public Criteria andProductNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductName + " <>", value,
                "productName");

            return this;
        }

        public Criteria andProductNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ProductName + " is null OR " +
                IProductVersionDAO.ProductName + " <>", value, "productName");

            return this;
        }

        public Criteria andProductNameNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ProductName + " >", value,
                "productName");

            return this;
        }

        public Criteria andProductNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductName + " >=", value,
                "productName");

            return this;
        }

        public Criteria andProductNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameLessThan(String value) {
            addCriterion(IProductVersionDAO.ProductName + " <", value,
                "productName");

            return this;
        }

        public Criteria andProductNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductName + " <=", value,
                "productName");

            return this;
        }

        public Criteria andProductNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductName + " like",
                buffer.toString(), "productName");

            return this;
        }

        public Criteria andProductNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductName + " not like",
                buffer.toString(), "productName");

            return this;
        }

        public Criteria andProductNameIn(List<String> values) {
            if (values.size() == 1) {
                return andProductNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductName + " in", values,
                    "productName");

                return this;
            }
        }

        public Criteria andProductNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductName + " not in",
                    values, "productName");

                return this;
            }
        }

        public Criteria andProductNameIn(String[] values) {
            if (values.length == 1) {
                return andProductNameEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductName + " in",
                    Arrays.asList(values), "productName");

                return this;
            }
        }

        public Criteria andProductNameNotIn(String[] values) {
            if (values.length == 1) {
                return andProductNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductName + " not in",
                    Arrays.asList(values), "productName");

                return this;
            }
        }

        public Criteria andProductNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductNameBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductName + " between", value1,
                value2, "productName");

            return this;
        }

        public Criteria andProductNameNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductName + " not between",
                value1, value2, "productName");

            return this;
        }

        public Criteria andProductCdoeIsNull() {
            addCriterion(IProductVersionDAO.ProductCdoe + " is null");

            return this;
        }

        public Criteria andProductCdoeIsNotNull() {
            addCriterion(IProductVersionDAO.ProductCdoe + " is not null");

            return this;
        }

        public Criteria andProductCdoeIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductCdoe + " is not null AND " +
                IProductVersionDAO.ProductCdoe + " <> ''");

            return this;
        }

        public Criteria andProductCdoeIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductCdoe + " is null OR " +
                IProductVersionDAO.ProductCdoe + " = '')");

            return this;
        }

        public Criteria andProductCdoeEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " = ", value,
                "productCdoe");

            return this;
        }

        public Criteria andProductCdoeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductCdoe);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductCdoeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " <>", value,
                "productCdoe");

            return this;
        }

        public Criteria andProductCdoeNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " is null OR " +
                IProductVersionDAO.ProductCdoe + " <>", value, "productCdoe");

            return this;
        }

        public Criteria andProductCdoeNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductCdoe);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductCdoeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " >", value,
                "productCdoe");

            return this;
        }

        public Criteria andProductCdoeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductCdoe);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductCdoeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " >=", value,
                "productCdoe");

            return this;
        }

        public Criteria andProductCdoeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductCdoe);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductCdoeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeLessThan(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " <", value,
                "productCdoe");

            return this;
        }

        public Criteria andProductCdoeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductCdoe);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductCdoeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductCdoe + " <=", value,
                "productCdoe");

            return this;
        }

        public Criteria andProductCdoeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductCdoe);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductCdoeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductCdoe + " like",
                buffer.toString(), "productCdoe");

            return this;
        }

        public Criteria andProductCdoeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductCdoe + " not like",
                buffer.toString(), "productCdoe");

            return this;
        }

        public Criteria andProductCdoeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductCdoeEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductCdoe + " in", values,
                    "productCdoe");

                return this;
            }
        }

        public Criteria andProductCdoeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductCdoeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductCdoe + " not in",
                    values, "productCdoe");

                return this;
            }
        }

        public Criteria andProductCdoeIn(String[] values) {
            if (values.length == 1) {
                return andProductCdoeEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductCdoe + " in",
                    Arrays.asList(values), "productCdoe");

                return this;
            }
        }

        public Criteria andProductCdoeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductCdoeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductCdoe + " not in",
                    Arrays.asList(values), "productCdoe");

                return this;
            }
        }

        public Criteria andProductCdoeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductCdoeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductCdoe + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductCdoeBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductCdoe + " between", value1,
                value2, "productCdoe");

            return this;
        }

        public Criteria andProductCdoeNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductCdoe + " not between",
                value1, value2, "productCdoe");

            return this;
        }

        public Criteria andProductStatusIsNull() {
            addCriterion(IProductVersionDAO.ProductStatus + " is null");

            return this;
        }

        public Criteria andProductStatusIsNotNull() {
            addCriterion(IProductVersionDAO.ProductStatus + " is not null");

            return this;
        }

        public Criteria andProductStatusIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductStatus +
                " is not null AND " + IProductVersionDAO.ProductStatus +
                " <> ''");

            return this;
        }

        public Criteria andProductStatusIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductStatus +
                " is null OR " + IProductVersionDAO.ProductStatus + " = '')");

            return this;
        }

        public Criteria andProductStatusEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " = ", value,
                "productStatus");

            return this;
        }

        public Criteria andProductStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductStatus);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " <>", value,
                "productStatus");

            return this;
        }

        public Criteria andProductStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " is null OR " +
                IProductVersionDAO.ProductStatus + " <>", value, "productStatus");

            return this;
        }

        public Criteria andProductStatusNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductStatus);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " >", value,
                "productStatus");

            return this;
        }

        public Criteria andProductStatusGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductStatus);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductStatusGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " >=", value,
                "productStatus");

            return this;
        }

        public Criteria andProductStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductStatus);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusLessThan(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " <", value,
                "productStatus");

            return this;
        }

        public Criteria andProductStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductStatus);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductStatus + " <=", value,
                "productStatus");

            return this;
        }

        public Criteria andProductStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductStatus);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductStatusLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductStatus + " like",
                buffer.toString(), "productStatus");

            return this;
        }

        public Criteria andProductStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductStatus + " not like",
                buffer.toString(), "productStatus");

            return this;
        }

        public Criteria andProductStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andProductStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductStatus + " in", values,
                    "productStatus");

                return this;
            }
        }

        public Criteria andProductStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductStatus + " not in",
                    values, "productStatus");

                return this;
            }
        }

        public Criteria andProductStatusIn(String[] values) {
            if (values.length == 1) {
                return andProductStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductStatus + " in",
                    Arrays.asList(values), "productStatus");

                return this;
            }
        }

        public Criteria andProductStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andProductStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductStatus + " not in",
                    Arrays.asList(values), "productStatus");

                return this;
            }
        }

        public Criteria andProductStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductStatus + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductStatusBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductStatus + " between", value1,
                value2, "productStatus");

            return this;
        }

        public Criteria andProductStatusNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductStatus + " not between",
                value1, value2, "productStatus");

            return this;
        }

        public Criteria andProductRemarksIsNull() {
            addCriterion(IProductVersionDAO.ProductRemarks + " is null");

            return this;
        }

        public Criteria andProductRemarksIsNotNull() {
            addCriterion(IProductVersionDAO.ProductRemarks + " is not null");

            return this;
        }

        public Criteria andProductRemarksIsNotEmpty() {
            addCriterion(IProductVersionDAO.ProductRemarks +
                " is not null AND " + IProductVersionDAO.ProductRemarks +
                " <> ''");

            return this;
        }

        public Criteria andProductRemarksIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ProductRemarks +
                " is null OR " + IProductVersionDAO.ProductRemarks + " = '')");

            return this;
        }

        public Criteria andProductRemarksEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " = ", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductRemarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " <>", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " is null OR " +
                IProductVersionDAO.ProductRemarks + " <>", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductRemarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRemarksNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " >", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductRemarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRemarksGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " >=", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductRemarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksLessThan(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " <", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductRemarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ProductRemarks + " <=", value,
                "productRemarks");

            return this;
        }

        public Criteria andProductRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ProductRemarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductRemarks + " like",
                buffer.toString(), "productRemarks");

            return this;
        }

        public Criteria andProductRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ProductRemarks + " not like",
                buffer.toString(), "productRemarks");

            return this;
        }

        public Criteria andProductRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductRemarks + " in", values,
                    "productRemarks");

                return this;
            }
        }

        public Criteria andProductRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ProductRemarks + " not in",
                    values, "productRemarks");

                return this;
            }
        }

        public Criteria andProductRemarksIn(String[] values) {
            if (values.length == 1) {
                return andProductRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductRemarks + " in",
                    Arrays.asList(values), "productRemarks");

                return this;
            }
        }

        public Criteria andProductRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ProductRemarks + " not in",
                    Arrays.asList(values), "productRemarks");

                return this;
            }
        }

        public Criteria andProductRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ProductRemarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductRemarksBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductRemarks + " between",
                value1, value2, "productRemarks");

            return this;
        }

        public Criteria andProductRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductVersionDAO.ProductRemarks + " not between",
                value1, value2, "productRemarks");

            return this;
        }

        public Criteria andParentProductVersionIsNull() {
            addCriterion(IProductVersionDAO.ParentProductVersion + " is null");

            return this;
        }

        public Criteria andParentProductVersionIsNotNull() {
            addCriterion(IProductVersionDAO.ParentProductVersion +
                " is not null");

            return this;
        }

        public Criteria andParentProductVersionIsNotEmpty() {
            addCriterion(IProductVersionDAO.ParentProductVersion +
                " is not null AND " + IProductVersionDAO.ParentProductVersion +
                " <> ''");

            return this;
        }

        public Criteria andParentProductVersionIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ParentProductVersion +
                " is null OR " + IProductVersionDAO.ParentProductVersion +
                " = '')");

            return this;
        }

        public Criteria andParentProductVersionEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " = ",
                value, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersion);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " <>",
                value, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion +
                " is null OR " + IProductVersionDAO.ParentProductVersion +
                " <>", value, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersion);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " >", value,
                "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersion);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " >=",
                value, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersion);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionLessThan(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " <", value,
                "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersion);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " <=",
                value, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersion);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ParentProductVersion + " like",
                buffer.toString(), "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ParentProductVersion + " not like",
                buffer.toString(), "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionIn(List<String> values) {
            if (values.size() == 1) {
                return andParentProductVersionEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersion + " in",
                    values, "parentProductVersion");

                return this;
            }
        }

        public Criteria andParentProductVersionNotIn(List<String> values) {
            if (values.size() == 1) {
                return andParentProductVersionNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersion +
                    " not in", values, "parentProductVersion");

                return this;
            }
        }

        public Criteria andParentProductVersionIn(String[] values) {
            if (values.length == 1) {
                return andParentProductVersionEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersion + " in",
                    Arrays.asList(values), "parentProductVersion");

                return this;
            }
        }

        public Criteria andParentProductVersionNotIn(String[] values) {
            if (values.length == 1) {
                return andParentProductVersionNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersion +
                    " not in", Arrays.asList(values), "parentProductVersion");

                return this;
            }
        }

        public Criteria andParentProductVersionIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ParentProductVersion + " between",
                value1, value2, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionNotBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ParentProductVersion +
                " not between", value1, value2, "parentProductVersion");

            return this;
        }

        public Criteria andParentProductVersionTypeIsNull() {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " is null");

            return this;
        }

        public Criteria andParentProductVersionTypeIsNotNull() {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " is not null");

            return this;
        }

        public Criteria andParentProductVersionTypeIsNotEmpty() {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " is not null AND " +
                IProductVersionDAO.ParentProductVersionType + " <> ''");

            return this;
        }

        public Criteria andParentProductVersionTypeIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ParentProductVersionType +
                " is null OR " + IProductVersionDAO.ParentProductVersionType +
                " = '')");

            return this;
        }

        public Criteria andParentProductVersionTypeEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " = ",
                value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionTypeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " <>",
                value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " is null OR " + IProductVersionDAO.ParentProductVersionType +
                " <>", value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionTypeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " >",
                value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionTypeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " >=",
                value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeLessThan(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " <",
                value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionTypeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeLessThanOrEqualTo(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " <=",
                value, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ParentProductVersionType + " like",
                buffer.toString(), "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " not like", buffer.toString(), "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andParentProductVersionTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionType +
                    " in", values, "parentProductVersionType");

                return this;
            }
        }

        public Criteria andParentProductVersionTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andParentProductVersionTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionType +
                    " not in", values, "parentProductVersionType");

                return this;
            }
        }

        public Criteria andParentProductVersionTypeIn(String[] values) {
            if (values.length == 1) {
                return andParentProductVersionTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionType +
                    " in", Arrays.asList(values), "parentProductVersionType");

                return this;
            }
        }

        public Criteria andParentProductVersionTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andParentProductVersionTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionType +
                    " not in", Arrays.asList(values), "parentProductVersionType");

                return this;
            }
        }

        public Criteria andParentProductVersionTypeIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionTypeBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " between", value1, value2, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionTypeNotBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ParentProductVersionType +
                " not between", value1, value2, "parentProductVersionType");

            return this;
        }

        public Criteria andParentProductVersionStatusIsNull() {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " is null");

            return this;
        }

        public Criteria andParentProductVersionStatusIsNotNull() {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " is not null");

            return this;
        }

        public Criteria andParentProductVersionStatusIsNotEmpty() {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " is not null AND " +
                IProductVersionDAO.ParentProductVersionStatus + " <> ''");

            return this;
        }

        public Criteria andParentProductVersionStatusIsEmpty() {
            addCriterion("(" + IProductVersionDAO.ParentProductVersionStatus +
                " is null OR " + IProductVersionDAO.ParentProductVersionStatus +
                " = '')");

            return this;
        }

        public Criteria andParentProductVersionStatusEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " = ",
                value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionStatus);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionStatusEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusNotEqualTo(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " <>",
                value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " is null OR " + IProductVersionDAO.ParentProductVersionStatus +
                " <>", value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionStatus);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionStatusNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusGreaterThan(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " >",
                value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionStatus);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionStatusGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " >=",
                value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionStatus);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusLessThan(String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " <",
                value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionStatus);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionStatusLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusLessThanOrEqualTo(
            String value) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus + " <=",
                value, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionDAO.ParentProductVersionStatus);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andParentProductVersionStatusLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " like", buffer.toString(), "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " not like", buffer.toString(), "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andParentProductVersionStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                    " in", values, "parentProductVersionStatus");

                return this;
            }
        }

        public Criteria andParentProductVersionStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andParentProductVersionStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                    " not in", values, "parentProductVersionStatus");

                return this;
            }
        }

        public Criteria andParentProductVersionStatusIn(String[] values) {
            if (values.length == 1) {
                return andParentProductVersionStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                    " in", Arrays.asList(values), "parentProductVersionStatus");

                return this;
            }
        }

        public Criteria andParentProductVersionStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andParentProductVersionStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                    " not in", Arrays.asList(values),
                    "parentProductVersionStatus");

                return this;
            }
        }

        public Criteria andParentProductVersionStatusIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andParentProductVersionStatusBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " between", value1, value2, "parentProductVersionStatus");

            return this;
        }

        public Criteria andParentProductVersionStatusNotBetween(String value1,
            String value2) {
            addCriterion(IProductVersionDAO.ParentProductVersionStatus +
                " not between", value1, value2, "parentProductVersionStatus");

            return this;
        }
    }
}
